from __future__ import annotations

import json
import os
import sys
from functools import lru_cache
from typing import Any, Optional
from unittest.mock import MagicMock, patch

# imports
import pytest  # used for our unit tests
import requests
from codeflash.api.cfapi import get_user_id
from packaging import version


# Mocks for dependencies used in get_user_id
class DummyConsole:
    quiet = False
    def print(self, msg):
        pass

class DummyLogger:
    def error(self, msg): pass
    def debug(self, msg): pass
def read_api_key_from_shell_config(): return None

console = DummyConsole()
logger = DummyLogger()
__version__ = "1.2.3"

# --- Functions under test and their dependencies (minimally mocked for testability) ---

@lru_cache(maxsize=1)
def get_codeflash_api_key() -> str:
    if console.quiet:  # lsp
        api_key = read_api_key_from_shell_config()
    else:
        api_key = os.environ.get("CODEFLASH_API_KEY") or read_api_key_from_shell_config()
    api_secret_docs_message = "For more information, refer to the documentation at [https://docs.codeflash.ai/getting-started/codeflash-github-actions#add-your-api-key-to-your-repository-secrets]."  # noqa
    if not api_key:
        msg = (
            "I didn't find a Codeflash API key in your environment.\nYou can generate one at "
            "https://app.codeflash.ai/app/apikeys ,\nthen set it as a CODEFLASH_API_KEY environment variable.\n"
            f"{api_secret_docs_message}"
        )
        raise OSError(msg)
    if not api_key.startswith("cf-"):
        msg = (
            f"Your Codeflash API key seems to be invalid. It should start with a 'cf-' prefix; I found '{api_key}' "
            f"instead.\nYou can generate one at https://app.codeflash.ai/app/apikeys ,\nthen set it as a "
            f"CODEFLASH_API_KEY environment variable."
        )
        raise OSError(msg)
    return api_key
from codeflash.api.cfapi import get_user_id

# ----------------- BASIC TEST CASES -----------------















#------------------------------------------------
from __future__ import annotations

import json
import os
import sys
from functools import lru_cache
from typing import Any, Optional
from unittest.mock import MagicMock, patch

# imports
import pytest  # used for our unit tests
import requests
from codeflash.api.cfapi import get_user_id


# Dummy classes and functions to allow the test to run in isolation
class DummyConsole:
    quiet = False
    def print(self, msg): pass

class DummyLogger:
    def error(self, msg): pass
    def debug(self, msg): pass

def exit_with_message(msg):
    raise SystemExit(msg)

def read_api_key_from_shell_config():
    return os.environ.get("SHELL_CODEFLASH_API_KEY")

def is_repo_a_fork():
    return False

console = DummyConsole()
logger = DummyLogger()

__version__ = "1.2.3"

class DummyVersion:
    @staticmethod
    def parse(v):
        return tuple(map(int, v.split('.')))

version = DummyVersion()

# Implementation of get_codeflash_api_key and ensure_codeflash_api_key
@lru_cache(maxsize=1)
def get_codeflash_api_key() -> str:
    if getattr(console, "quiet", False):
        api_key = read_api_key_from_shell_config()
    else:
        api_key = os.environ.get("CODEFLASH_API_KEY") or read_api_key_from_shell_config()

    api_secret_docs_message = "For more information, refer to the documentation at [https://docs.codeflash.ai/getting-started/codeflash-github-actions#add-your-api-key-to-your-repository-secrets]."  # noqa
    if not api_key:
        msg = (
            "I didn't find a Codeflash API key in your environment.\nYou can generate one at "
            "https://app.codeflash.ai/app/apikeys ,\nthen set it as a CODEFLASH_API_KEY environment variable.\n"
            f"{api_secret_docs_message}"
        )
        if is_repo_a_fork():
            msg = (
                "Codeflash API key not detected in your environment. It appears you're running Codeflash from a GitHub fork.\n"
                "For external contributors, please ensure you've added your own API key to your fork's repository secrets and set it as the CODEFLASH_API_KEY environment variable.\n"
                f"{api_secret_docs_message}"
            )
            exit_with_message(msg)
        raise OSError(msg)
    if not api_key.startswith("cf-"):
        msg = (
            f"Your Codeflash API key seems to be invalid. It should start with a 'cf-' prefix; I found '{api_key}' "
            f"instead.\nYou can generate one at https://app.codeflash.ai/app/apikeys ,\nthen set it as a "
            f"CODEFLASH_API_KEY environment variable."
        )
        raise OSError(msg)
    return api_key
from codeflash.api.cfapi import get_user_id


@pytest.fixture
def patch_env(monkeypatch):
    # Helper fixture to patch environment variables
    def _set_env(key, value):
        monkeypatch.setenv(key, value)
    return _set_env

# ---- Basic Test Cases ----

def test_get_user_id_returns_userid_on_success(monkeypatch, patch_env):
    """Basic: Should return userId string if API returns 200 and userId present."""
    patch_env("CODEFLASH_API_KEY", "cf-123456")
    # Mock API response
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.text = '{"userId":"abc123"}'
    mock_response.json.return_value = {"userId": "abc123"}
    with patch("requests.get", return_value=mock_response):
        codeflash_output = get_user_id() # 270μs -> 265μs (2.21% faster)

def test_get_user_id_returns_userid_if_text_is_id(monkeypatch, patch_env):
    """Basic: Should return response.text directly if 'min_version' not in text."""
    patch_env("CODEFLASH_API_KEY", "cf-abcdef")
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.text = "user-xyz"
    mock_response.json.side_effect = Exception("Should not be called")
    with patch("requests.get", return_value=mock_response):
        codeflash_output = get_user_id() # 249μs -> 248μs (0.218% faster)

def test_get_user_id_returns_none_on_api_401(monkeypatch, patch_env):
    """Basic: Should return None if API returns 401 Unauthorized."""
    patch_env("CODEFLASH_API_KEY", "cf-abcdef")
    mock_response = MagicMock()
    mock_response.status_code = 401
    mock_response.reason = "Unauthorized"
    with patch("requests.get", return_value=mock_response):
        codeflash_output = get_user_id() # 1.00ms -> 982μs (2.14% faster)

def test_get_user_id_returns_none_if_no_api_key(monkeypatch):
    """Basic: Should return None if no API key is present in env or shell config."""
    # Remove env var and shell config
    monkeypatch.delenv("CODEFLASH_API_KEY", raising=False)
    monkeypatch.delenv("SHELL_CODEFLASH_API_KEY", raising=False)
    codeflash_output = get_user_id() # 115ms -> 102ms (12.0% faster)

# ---- Edge Test Cases ----


def test_get_user_id_min_version_too_high(monkeypatch, patch_env):
    """Edge: Should exit if min_version in response is higher than __version__."""
    patch_env("CODEFLASH_API_KEY", "cf-abcdef")
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.text = '{"userId":"abc123","min_version":"9.9.9"}'
    mock_response.json.return_value = {"userId": "abc123", "min_version": "9.9.9"}
    # Patch sys.exit to raise SystemExit so we can catch it
    with patch("requests.get", return_value=mock_response), \
         patch("sys.exit", side_effect=SystemExit) as mock_exit:
        with pytest.raises(SystemExit):
            get_user_id()
        mock_exit.assert_called_once_with(1)


def test_get_user_id_returns_none_if_userid_missing(monkeypatch, patch_env):
    """Edge: Should return None if API returns 200 but no userId in response."""
    patch_env("CODEFLASH_API_KEY", "cf-abcdef")
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.text = '{"foo":"bar"}'
    mock_response.json.return_value = {"foo": "bar"}
    with patch("requests.get", return_value=mock_response):
        codeflash_output = get_user_id() # 261μs -> 256μs (1.72% faster)

def test_get_user_id_returns_none_if_api_returns_error(monkeypatch, patch_env):
    """Edge: Should return None if API returns non-200 and error message in JSON."""
    patch_env("CODEFLASH_API_KEY", "cf-abcdef")
    mock_response = MagicMock()
    mock_response.status_code = 403
    mock_response.reason = "Forbidden"
    mock_response.json.return_value = {"error": "forbidden"}
    with patch("requests.get", return_value=mock_response):
        codeflash_output = get_user_id() # 856μs -> 854μs (0.200% faster)

def test_get_user_id_handles_non_json_response(monkeypatch, patch_env):
    """Edge: Should return None if API returns 500 and text is not JSON."""
    patch_env("CODEFLASH_API_KEY", "cf-abcdef")
    mock_response = MagicMock()
    mock_response.status_code = 500
    mock_response.reason = "Internal Server Error"
    mock_response.text = "Server error"
    mock_response.json.side_effect = ValueError("Not JSON")
    with patch("requests.get", return_value=mock_response):
        codeflash_output = get_user_id() # 844μs -> 842μs (0.195% faster)

def test_get_user_id_handles_shell_config(monkeypatch):
    """Edge: Should use shell config if CODEFLASH_API_KEY is missing and console.quiet is True."""
    monkeypatch.delenv("CODEFLASH_API_KEY", raising=False)
    monkeypatch.setenv("SHELL_CODEFLASH_API_KEY", "cf-shellkey")
    monkeypatch.setattr(console, "quiet", True)
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.text = "shell-userid"
    with patch("requests.get", return_value=mock_response):
        codeflash_output = get_user_id() # 251μs -> 257μs (2.08% slower)



def test_get_user_id_large_scale_many_different_users(monkeypatch):
    """Large Scale: Should handle different API keys and return correct userIds."""
    # Simulate up to 10 different users
    for i in range(10):
        key = f"cf-key-{i}"
        user_id = f"user-{i}"
        with patch.dict(os.environ, {"CODEFLASH_API_KEY": key}):
            get_codeflash_api_key.cache_clear()
            get_user_id.cache_clear()
            mock_response = MagicMock()
            mock_response.status_code = 200
            mock_response.text = user_id
            with patch("requests.get", return_value=mock_response):
                codeflash_output = get_user_id()


def test_get_user_id_large_scale_batch(monkeypatch, patch_env):
    """Large Scale: Should handle 1000 sequential calls with different userIds (simulate no cache)."""
    patch_env("CODEFLASH_API_KEY", "cf-abcdef")
    for i in range(20):  # keep under 1000 for test speed
        get_user_id.cache_clear()
        user_id = f"user-{i}"
        mock_response = MagicMock()
        mock_response.status_code = 200
        mock_response.text = user_id
        with patch("requests.get", return_value=mock_response):
            codeflash_output = get_user_id()
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.